
// using System.Collections;
// using System.Collections.Generic;
// using System.Net.Sockets;
// using System.Net;
// using System;
// using Newtonsoft.Json;  //引用命名空间
// using System.Linq;


// public enum NetEvent
// {
//     ConnectSucc = 1,
//     ConnectFail = 1,
//     Close = 1,
// }


// // NetManager定义
// public static class NetManager
// {
//     static Socket socket;
//     static int len_readbuff = 1024;
//     // static byte[] readBuff = new byte[len_readbuff];
//     static ByteArray readBuff = new ByteArray(len_readbuff);
//     // static int buffCount = 0;  // 记录有多长, 已被`ByteArray.length`取代

//     static int head_len = 2;  // 消息头的长度, int16则为2字节, int32则4字节
//     // static string recvStr = "";

//     static int len_sendbytes = 1024;
//     static byte[] sendBytes = new byte[len_sendbytes];
//     // static int readIdx = 0;  // 缓冲区偏移值
//     // static int length = 0;  // 缓冲区剩余长度

//     static Queue<ByteArray> writeQueue = new Queue<ByteArray>();

//     static bool isClosing = false;

//     // 委托类型
//     public delegate void EventListener(String err);

//     private static Dictionary<NetEvent, EventListener> eventListeners = new Dictionary<NetEvent, EventListener>();

//     public delegate void MsgListener(String str);
//     // public delegate void MsgListener(MsgBase msgBase);

//     // 监听列表
//     private static Dictionary<string, MsgListener> listeners = new Dictionary<string, MsgListener>();

//     static List<String> msgList = new List<string>();

//     public static void AddEventListener(NetEvent netEvent, EventListener listener)
//     {
//         // Debug.Log("AddEventListener ---" + netEvent);
//         if (eventListeners.ContainsKey(netEvent))
//         {
//             eventListeners[netEvent] += listener;
//         }
//         else
//         {
//             eventListeners[netEvent] = listener;
//         }
//     }

//     public static void RemoveEventListener(NetEvent netEvent, EventListener listener)
//     {
//         if (eventListeners.ContainsKey(netEvent))
//         {
//             eventListeners[netEvent] -= listener;
//             if (eventListeners[netEvent] == null)
//             {
//                 eventListeners.Remove(netEvent);
//             }
//         }
//     }

//     public static void FireEvent(NetEvent netEvent, string err)
//     {
//         if (eventListeners.ContainsKey(netEvent))
//         {
//             eventListeners[netEvent](err);
//         }
//     }

//     // 添加监听
//     public static void AddListener(string msgName, MsgListener listener)
//     {
//         // Debug.Log("AddListener ---" + msgName);
//         if (listeners.ContainsKey(msgName))
//         {
//             listeners[msgName] += listener;
//         }
//         else
//         {
//             listeners[msgName] = listener;
//         }
//     }

//     public static void RemoveListener(string msgName, MsgListener listener)
//     {
//         if (listeners.ContainsKey(msgName))
//         {
//             listeners[msgName] -= listener;
//             if (listeners[msgName] == null)
//             {
//                 listeners.Remove(msgName);
//             }
//         }
//     }

//     // 分发消息
//     public static void FireMsg(string msgName, MsgBase msgBase)
//     {
//         if (listeners.ContainsKey(msgName))
//         {
//             listeners[msgName](msgBase.ToString());
//         }
//     }

//     // 获取描述
//     public static string GetDesc()
//     {
//         if (socket == null) return "";
//         if (!socket.Connected) return "";
//         return socket.LocalEndPoint.ToString();
//     }

//     // 连接
//     public static void Connect(string ip, int port)
//     {

//         // Socket
//         socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
//         // 绑定端口
//         // int bind_port = BdUtils.TimeUtils.get_random_number(8800, 8900);
//         // socket.Bind(new IPEndPoint(IPAddress.Parse("127.0.0.1"), bind_port));
//         // Connect (用同步方式简化代码)
//         socket.Connect(ip, port);

//         // BeginRecieve
//         // socket.BeginReceive(readBuff, 0, len_readbuff, 0, ReceiveCallback, socket);
//         // socket.BeginReceive(readBuff, buffCount, len_readbuff - buffCount, 0, ReceiveCallback, socket);
//         socket.BeginReceive(readBuff.bytes, readBuff.writeIdx, readBuff.remain, 0, ReceiveCallback, socket);
//         Debug.Log("--- 成建立功连接: " + ip + ':' + port);
//     }

//     public static void Close()
//     {
//         socket.Close();
//     }

//     // Receive回调
//     private static void ReceiveCallback(IAsyncResult ar)
//     {
//         try
//         {
//             Socket socket = (Socket)ar.AsyncState;
//             int count = socket.EndReceive(ar);  // 获取接收数据的长度

//             readBuff.writeIdx += count;
//             OnReceiveData();

//             // 继续接受数据
//             if (readBuff.remain < 8)
//             {
//                 readBuff.MoveBytes();
//                 readBuff.Resize(readBuff.length * 2);
//             }
//             socket.BeginReceive(readBuff.bytes, readBuff.writeIdx, readBuff.remain, 0, ReceiveCallback, socket);
//         }
//         catch (SocketException ex)
//         {
//             string e = "Socket Receive fail " + ex.ToString();
//             BdUtils.log(e);
//         }
//     }

//     public static void OnReceiveData()
//     {
//         // 消息长度
//         if (readBuff.length <= head_len)
//             return;

//         // 解析bodyLength
//         Int16 bodyLength = readBuff.ReadInt16();

//         if (bodyLength < 0)
//         {
//             BdUtils.log($"*** 出现bodyLength[{bodyLength}]值错误的情况!");
//             BdUtils.log($"[此时的缓冲区] readBuff = {System.Text.Encoding.UTF8.GetString(readBuff.bytes)}");
//             return;
//         }

//         if (bodyLength > readBuff.length)  // 本条消息还没接收完
//         {
//             readBuff.readIdx -= head_len;  // 返还`head_len`字节的长度信息
//             return;
//         }

//         // 消息体
//         // string s = System.Text.Encoding.UTF8.GetString(readBuff, head_len, bodyLength);
//         byte[] stringByte = new byte[bodyLength];
//         readBuff.Read(stringByte, 0, bodyLength);
//         string recvStr = System.Text.Encoding.UTF8.GetString(stringByte);

//         if (BdUtils.is_null(recvStr))
//         {
//             BdUtils.log("! --- recvStr is_null !!!");
//             BdUtils.TimeUtils.sleep(2);
//             return;
//         }

//         // 消息处理
//         lock (msgList)
//             msgList.Add(recvStr);

//         //继续读取消息
//         if (readBuff.length > head_len)
//         {
//             OnReceiveData();
//         }

//     }

//     // 发送
//     public static void Send(string sendStr)
//     {
//         if (socket == null) return;
//         if (!socket.Connected) return;

//         // 长度信息1 bodyLength
//         byte[] bodyBytes = System.Text.Encoding.UTF8.GetBytes(sendStr);
//         Int16 len = (Int16)bodyBytes.Length;
//         byte[] lenBytes = BitConverter.GetBytes(len);
//         if (!BitConverter.IsLittleEndian)
//         {
//             BdUtils.log("[Send] Reverse lenBytes");
//             lenBytes.Reverse();
//         }
//         byte[] sendBytes = lenBytes.Concat(bodyBytes).ToArray();

//         ByteArray ba = new ByteArray(sendBytes);
//         int count = 0;
//         // 这里实现`完整发送数据`的功能
//         lock (writeQueue)
//         {
//             writeQueue.Enqueue(ba);
//             count = writeQueue.Count;
//         }

//         if (writeQueue.Count == 1)
//         {
//             socket.BeginSend(ba.bytes, ba.readIdx, ba.length, 0, SendCallback, socket);
//         }
//     }
//     public static void Send(object sendStr)
//     {
//         Send(sendStr.ToString());
//     }


//     public static void SendCallback(IAsyncResult ar)
//     {
//         try
//         {
//             Socket socket = (Socket)ar.AsyncState;
//             int count = socket.EndSend(ar);

//             ByteArray ba;

//             // 判断是否发送完整
//             lock (writeQueue)
//             {
//                 ba = writeQueue.First();
//             }
//             ba.readIdx += count;

//             if (ba.length == 0)  // 发送完整
//             {
//                 lock (writeQueue)
//                 {
//                     writeQueue.Dequeue();
//                     if (writeQueue.Count() != 0)
//                     {
//                         ba = writeQueue.First();
//                     }
//                     else
//                         ba = null;
//                 }

//             }
//             if (ba != null)  // 发送不完整, 或者发送完整且存在第二条数据
//             {
//                 BdUtils.log($"--- ba | readIdx[{ba.readIdx}] | length[{ba.length}]");
//                 socket.BeginSend(ba.bytes, ba.readIdx, ba.length, 0, SendCallback, socket);
//             }

//         }
//         catch (SocketException ex)
//         {
//             Debug.Log("Socket Send fail" + ex.ToString());
//         }
//     }

//     // Update
//     public static void Update()
//     {
//         // BdUtils.log($"~~~ NetManager.Update at {BdUtils.TimeUtils.get_time_string("s2", get_date: false)}");

//         if (msgList.Count <= 0) return;

//         String msgStr = "";
//         lock (msgList)
//         {
//             msgStr = msgList[0];
//             msgList.RemoveAt(0);
//         }

//         if (msgStr == "")
//         {
//             BdUtils.log("!!!!!");
//             BdUtils.TimeUtils.sleep(1);
//             return;
//         }
//         if (BdUtils.is_null(msgStr))
//         {
//             BdUtils.log("! --- Update msgStr is_null !!!");
//             BdUtils.TimeUtils.sleep(1);
//             return;
//         }

//         // BdUtils.log($"*** Update received msgStr: {msgStr}");

//         var msg_dc = BdUtils.conv_json_to_dict(msgStr);
//         // BdUtils.log("~~~~~ ", s, BdUtils.conv_json_to_dict(s, new string[] { "protoName" }));
//         var protoName = msg_dc["protoName"].ToString();

//         // 监听回调
//         if (listeners.ContainsKey(protoName))
//         {
//             listeners[protoName](msgStr);
//         }
//         else
//         {
//             MsgHandle.run_method_by_msg(msgStr, msg_dc);  // 使用`MsgHandle`类
//         }

//     }
// }
